home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2005 October / PCWOCT05.iso / Software / Resources / CutePDF 2.3 / converter.exe / GNUGS / PDF_FONT.PS < prev    next >
Text File  |  2002-04-17  |  39KB  |  1,224 lines
  1. %    Copyright (C) 1994-2002 artofcode LLC.  All rights reserved.
  2. % 
  3. % This software is provided AS-IS with no warranty, either express or
  4. % implied.
  5. % 
  6. % This software is distributed under license and may not be copied,
  7. % modified or distributed except as expressly authorized under the terms
  8. % of the license contained in the file LICENSE in this distribution.
  9. % 
  10. % For more information about licensing, please refer to
  11. % http://www.ghostscript.com/licensing/. For information on
  12. % commercial licensing, go to http://www.artifex.com/licensing/ or
  13. % contact Artifex Software, Inc., 101 Lucas Valley Road #110,
  14. % San Rafael, CA  94903, U.S.A., +1(415)492-9861.
  15.  
  16. % $Id: pdf_font.ps,v 1.23.2.6 2002/04/16 06:11:29 giles Exp $
  17. % pdf_font.ps
  18. % PDF font operations.
  19.  
  20. /.setlanguagelevel where { pop 2 .setlanguagelevel } if
  21. .currentglobal true .setglobal
  22. /pdfdict where { pop } { /pdfdict 100 dict def } ifelse
  23. GS_PDF_ProcSet begin
  24. pdfdict begin
  25.  
  26. % We cache the PostScript font in an additional element of the
  27. % font resource dictionary, called PSFont.
  28.  
  29. % ---------------- Encodings ---------------- %
  30.  
  31. % Apply a list of differences to an Encoding.
  32. % Note that the differences may cause the array to grow.
  33. /updateencoding {    % <encoding> <differences> updateencoding <enc'>
  34.     % Calculate the length of the result.
  35.   exch 0 2 index {
  36.     dup type /nametype ne { exch pop } { pop 1 add } ifelse
  37.   } forall
  38.   1 index length .max array dup 0 4 -1 roll putinterval
  39.   exch 0 exch {
  40.         % Stack: enc' code element
  41.     dup type /nametype ne
  42.       { exch pop }
  43.       { 3 copy put pop 1 add }
  44.     ifelse
  45.   } forall pop
  46. } bdef
  47.  
  48. % Get the Encoding for a font.
  49. /getencoding        % <base-encoding> <font-resource> getencoding <enc>
  50.  { /Encoding knownoget
  51.     { dup type /nametype eq
  52.        { 
  53.          % The published PDF specification says the Encoding name
  54.          % "must be" one of the 3 predefined Encodings, implying
  55.          % that an error should occur if it isn't.  However, Acrobat
  56.          % Reader simply ignores unknown names, and since there are
  57.          % some buggy applications that rely on this, we do the same.
  58.  
  59.          dup dup dup /MacRomanEncoding eq
  60.          exch /MacExpertEncoding eq or 
  61.          exch /WinAnsiEncoding eq or
  62.            { exch pop findencoding
  63.            }
  64.            { pop
  65.            }
  66.          ifelse
  67.        }
  68.        { dup /BaseEncoding knownoget
  69.       { findencoding 3 -1 roll pop exch
  70.       }
  71.      if
  72.      /Differences knownoget { updateencoding } if
  73.        }
  74.       ifelse
  75.     }
  76.    if
  77.  } bdef
  78.  
  79. % Rename a font with a generated name.
  80. /renamefont {        % <fontdict> renamefont <font'>
  81.   dup /FontName 2 copy get genfontname dup 5 1 roll put definefont
  82. } bind def
  83.  
  84. % Adjust a font according to the Encoding and Widths in the font resource.
  85. /adjustfont {        % <font-resource> <font> adjustfont <font'>
  86.   getfontencoding
  87.   getfontmetrics 4 -1 roll pop .updatefont { renamefont } if
  88. } bind def
  89.  
  90. % Get the (possibly modified) encoding of a font.
  91. /getfontencoding {    % <font-resource> <font> getfontencoding
  92.             %   <font-resource> <font> <Encoding|null>
  93.   1 index /Encoding known {
  94.     dup /Encoding .knownget { 2 index getencoding } { null } ifelse
  95.   } {
  96.     null
  97.   } ifelse
  98. } bdef
  99.  
  100. /find_in_diff     % <Differences> <index> find_in_diff <bool>
  101. { false exch 0 4 3 roll
  102.   { dup type /nametype ne { exch pop } { pop 1 add } ifelse
  103.     2 copy eq {
  104.       pop pop pop true 0 0 exit
  105.     } if
  106.   } forall
  107.   pop pop
  108. } bdef
  109.  
  110. % Get the metrics of a font, if specified.
  111. /getfontmetrics {    % <font-resource> <font> <Encoding|null> getfontmetrics
  112.             %   <font-resource> <font> <Encoding|null>
  113.             %   <Metrics|null>
  114.   2 index /Widths known {
  115.     dup null eq { pop dup /Encoding get } if
  116.     4 dict begin
  117.       /Encoding exch def
  118.       /Metrics Encoding length dict def
  119.       exch
  120.       dup /Widths oget /Widths exch def
  121.         % Stack: font font-res
  122.         % Note that widths are always based on a 1000-unit
  123.         % character space, but the FontMatrix may specify
  124.         % some other scale factor.  Compensate for this here,
  125.         % by scaling the Widths if necessary.
  126.       0.001 2 index /FontMatrix get 0 get div
  127.         % Stack: font font-res mscale
  128.       1 index /FirstChar oget dup 1 4 index /LastChar oget
  129.        {    % Stack: font font-res mscale first-char index
  130.      Encoding 1 index get
  131.      Widths 2 index 4 index sub oget
  132.          % Stack: font font-res mscale first-char index charname width
  133.      4 index mul
  134.         % The following 'loop' is only context for 'exit'.
  135.      {    
  136.         % Work around a bug in pdfTeX, which can generate Encoding
  137.         % vectors containing nulls :
  138.        1 index null eq { exit } if
  139.         % There is a hack here to deal with encodings where the
  140.         % same character appears more than once, because the Metrics
  141.         % dictionary works by character name, not by character code.
  142.         % We prefer to take (1) non-zero width, and (2) width for 
  143.         % the character code which appears in Differences.
  144.        Metrics 2 index .knownget not { 0 } if 0 ne {
  145.          5 index /Encoding knownoget not { exit } if
  146.          dup type /dicttype ne { pop exit } if
  147.          /Differences knownoget not { exit } if
  148.          3 index //find_in_diff exec not { exit } if
  149.        } if
  150.        2 copy Metrics 3 1 roll put
  151.        exit
  152.      } loop
  153.      pop pop pop
  154.        }
  155.       for pop
  156.         % Now fill in the MissingWidth for any encoded characters
  157.         % that aren't in Metrics already.  Note that built-in
  158.         % fonts may have Widths/FirstChar/LastChar but no
  159.         % FontDescriptor, so we must check for this.
  160.         % Stack: font font-res mscale
  161.       1 index /FontDescriptor knownoget {
  162.     Metrics exch
  163.     /MissingWidth knownoget { 2 index mul } { 0 } ifelse exch
  164.     Encoding {
  165.         % Stack: font font-res mscale missing-width metrics charname
  166.         % Work around the abovementioned pdfTeX bug.
  167.       dup null ne {
  168.         2 copy known not { 2 copy 4 index put } if pop
  169.       } {
  170.         pop
  171.       } ifelse
  172.     } forall pop pop pop
  173.       } {
  174.     pop
  175.       } ifelse
  176.     exch Encoding Metrics end
  177.   } {
  178.     null
  179.   } ifelse
  180. } bdef
  181.  
  182. currentdict /find_in_diff undef
  183.  
  184. % ---------------- Descriptors ---------------- %
  185.  
  186. % Partial descriptors for the 14 built-in fonts.  Note that
  187. % from PDF 1.1 to PDF 1.2, the meaning of the Flag 6 in the FontDescriptor
  188. % object has undergone a subtle change in its meaning which has serious
  189. % consequences for searching with Acrobat:
  190. % In PDF 1.1, the flag meant: Font has StandardEncoding
  191. % In PDF 1.2, the flag means: Font has (subset of) StandardRomanCharacterSet
  192. /standardfontdescriptors mark
  193.   /Courier mark /Flags 16#23 .dicttomark
  194.   /Courier-Oblique 1 index
  195.   /Courier-Bold 1 index
  196.   /Courier-BoldOblique 1 index
  197.   /Helvetica mark /Flags 16#20 .dicttomark
  198.   /Helvetica-Oblique 1 index
  199.   /Helvetica-Bold 1 index
  200.   /Helvetica-BoldOblique 1 index
  201.   /Times-Roman mark /Flags 16#22 .dicttomark
  202.   /Times-Bold 1 index
  203.   /Times-Italic mark /Flags 16#62 .dicttomark
  204.   /Times-BoldItalic 1 index
  205.   /Symbol mark /Flags 16#4 .dicttomark
  206.   /ZapfDingbats 1 index
  207. .dicttomark readonly def
  208.  
  209. % ---------------- Utilities ---------------- %
  210.  
  211. /.glyphpath {    % <glyphname> <boolean> .glyphpath -
  212.   % another glyphpath written in addxchar.ps does not work here...
  213.   currentfont 3 1 roll exch
  214.   currentfont dup length dict begin
  215.     { 1 index /Encoding eq { pop [ 3 -1 roll ] def } { def } ifelse } forall
  216.   currentdict end /.glyphpathfont exch definefont
  217.   setfont <00> exch charpath setfont
  218. } bdef
  219.  
  220. /makeboldfont {    % <basefont> <strokewidth> makeboldfont <boldfont>
  221.   10 dict begin
  222.     /strokewidth exch def
  223.     /basefont exch def
  224.     /FontMatrix matrix def
  225.     %/FontName basefont /FontName get def
  226.     /FontName /.boldfont def
  227.     /FontType 3 def
  228.     /Encoding basefont /Encoding get def
  229.     /FontBBox [ basefont /FontBBox get cvx exec
  230.       4 2 roll basefont /FontMatrix get transform
  231.       4 2 roll basefont /FontMatrix get transform
  232.     ] def
  233.     /BuildGlyph {
  234.       gsave
  235.       exch begin
  236.         basefont setfont
  237.         strokewidth setlinewidth
  238.         1 setlinejoin
  239.         newpath
  240.         0 0 moveto dup false .glyphpath stroke
  241.         0 0 moveto glyphshow
  242.         currentpoint setcharwidth
  243.       end
  244.       grestore
  245.     } bind def
  246.    currentdict
  247.   end
  248.   dup /FontName get exch definefont
  249. } bind def
  250.  
  251. % Fabricate a font name by adding ?'s on the end.
  252. /genfontname        % <name> genfontname <name>
  253.  { dup length string cvs
  254.     { (?) concatstrings
  255.       dup cvn FontDirectory exch known not { cvn exit } if
  256.     }
  257.    loop
  258.  } bdef
  259.  
  260. % Find a font, and adjust its encoding if necessary.
  261. /.pdfdfndict mark
  262.   /defaultfontname /Helvetica
  263. .dicttomark readonly def
  264. /pdffindfont {        % <font-resource> <fontname> pdffindfont <font>
  265.         % If the font isn't available, synthesize one based on
  266.         % its descriptor.
  267.   dup /Font resourcestatus {
  268.     pop pop findfont
  269.   } {
  270.     1 index /FontDescriptor knownoget {
  271.         % Stack: font-res fontname fontdesc
  272.       dup /Flags oget
  273.       dup 16#40 and -6 bitshift        % 1, oblique/italic
  274.       1 index 16#40000 and -17 bitshift add    % 2, bold
  275.       exch 16#2 and 2 bitshift add    % 8, serif
  276.         % We should look at the fixed flag, too.
  277.         % Stack: font-res fontname fontdesc properties
  278.       1 index /FontName oget exch
  279.         % Analyzes font name and extract "Narrow" property
  280.         % which is not described by the FontDescriptor Flags.
  281.       0 2 index .fontnameproperties 4 and or
  282.         % Rebind the default font name to Helvetica so that
  283.         % fonts with no properties are handled correctly.
  284.       //.pdfdfndict begin .substitutefontname end
  285.         % Stack: font-res fontname fontdesc substname|null
  286.       Fontmap 1 index known not {
  287.         % No available good substitution, use the standard one.
  288.     pop 1 index .substitutefont
  289.       } if
  290.       QUIET not {
  291.     (Substituting font ) print dup =only
  292.     ( for ) print 2 index =only (.) = flush
  293.       } if
  294.       3 -1 roll pop findfont
  295.         % Stack: font-res fontdesc font
  296.         % If this is a small-caps font, replace the CharString
  297.         % entries for a..z.
  298.       exch /Flags oget 16#20000 and 0 ne {
  299.     true .copyfontdict
  300.     dup /CharStrings 2 copy get dup length dict .copydict
  301.     4 index /FirstChar get 97 .max
  302.     5 index /LastChar get 122 .min 1 exch {
  303.         % Stack: font-res font' font' /CharStrings charstrings code
  304.         % Note that this only remaps a-z, not accented characters.
  305.       5 index /Widths oget 1 index 7 index /FirstChar get sub oget
  306.       1 string dup 0 5 -1 roll put
  307.         % Stack: font-res font' font' /CharStrings charstrings code
  308.         %   width (x)
  309.       2 index exch dup cvn exch
  310.       dup 0 2 copy get 32 sub put 4 -1 roll {
  311.             % Stack: operand (X) width
  312.         0 setcharwidth exch pop
  313.         currentfont /FontMatrix get matrix invertmatrix concat
  314.         0.7 dup scale 0 0 moveto show
  315.       } /exec cvx 4 packedarray cvx put
  316.     } for put
  317.     renamefont
  318.       } if
  319.     } {
  320.         % No descriptor available, use the default algorithm.
  321.       findfont
  322.     } ifelse
  323.   } ifelse adjustfont
  324. } bdef
  325. /findpdffont {    % <font-resource> <fontname> findpdffont <font>
  326.   {} 3 1 roll            % proc fnres fnname
  327.   [
  328.     [ (,Bold)        { .03 makeboldfont } ]
  329.     [ (,BoldItalic)    { .03 makeboldfont [ 1 0 .3 1 0 0 ] makefont } bind ]
  330.     [ (,Italic)        { [ 1 0 .3 1 0 0 ] makefont } bind ]
  331.   ] {
  332.     1 index dup length string cvs
  333.     1 index 0 get tailmatch {    % proc fnres fnname []
  334.       3 -1 roll pop exch 1 get    % proc fnres pre-fnname proc
  335.       4 -1 roll pop 3 1 roll    % proc fnres pre-fnname
  336.       exit
  337.     } { pop pop } ifelse     % proc fnres fnname
  338.   } forall
  339.   pdffindfont exch exec
  340. } bdef
  341.  
  342. % ---------------- Type 1 fonts ---------------- %
  343.  
  344. /buildType1        % <Type1-font-resource> buildType1 <font>
  345.  { dup /BaseFont get pdffindfont
  346.  } bdef
  347.  
  348. % The state dictionary for the embedded Type 1 font reading procedure
  349. % has the following keys and values:
  350. %    data - stream (filter)
  351. %    buffer, buffer2 - string
  352. %    hexify - procedure to convert buffer to hex if needed
  353. %    leftstr - string containing (non-negative) integer
  354. %    sectionstr - string containing a character 0 .. 3
  355. %    stream - (stream) dictionary
  356. %    proc - procedure of the form {-dict- type1read}
  357. %       pfbhdr - string containing 16#80 if PFB, 0 otherwise
  358. % When the procedure is executing, this dictionary is current.
  359. % leftstr and sectionstr are strings so that we can change their values
  360. % reliably in case the font executes a restore!
  361. % We also have to do something special about embedded fonts that
  362. % execute definefont more than once -- that is the function of topFontDict.
  363.  
  364. % Read an embedded Type 1 font.
  365. /readfontfilter {    % <proc> readfontfilter <filter>
  366.   0 () /SubFileDecode filter
  367. } bdef
  368. /readtype1dict 5 dict dup begin
  369.   /definefont {
  370.     dup topFontDict eq topFontDict null eq or {
  371.       dup wcheck not { dup length dict copy } if
  372.       exch pop savedFontName exch
  373.     } if
  374.     //systemdict /definefont get exec
  375.   } bdef
  376.   /eexec {
  377.     % Assume the font dictionary is directly below the file on the stack
  378.     count 0 gt { /topFontDict 2 index cvlit store } if
  379.     55665 /eexecDecode filter
  380.     //systemdict begin readtype1dictcopy begin cvx stopped
  381.     currentdict readtype1dictcopy eq { end } if
  382.     currentdict //systemdict eq { end } if
  383.      { stop } if
  384.   } bdef
  385. end readonly def
  386. /readtype1 {        % <font-resource> <stream-dict> readtype1 <font>
  387.         % Read the definition, using a procedure-based filter
  388.         % that turns binary/hex conversion on and off
  389.         % at the right times.
  390.    1 index exch
  391.    PDFfile fileposition 3 1 roll
  392.    11 dict begin
  393.      /leftstr (          ) 10 string copy def
  394.        dup /Length1 oget leftstr cvs pop
  395.      /sectionstr <00> 1 string copy def
  396.      /pfbhdr <00> 1 string copy def
  397.      /stream 1 index def
  398.      true resolvestream /data exch def
  399.      /buffer 1000 string def        % arbitrary
  400.      /buffer2 buffer length 2.1 div cvi 1 sub string def
  401.      /hexify /buf2hex load def
  402.    currentdict end
  403.    /type1read cvx 2 array astore cvx dup 0 get /proc 2 index put
  404.    readfontfilter
  405.         % Some buggy embedded fonts leave extra junk on the stack,
  406.         % so we have to make a closure that records the stack depth
  407.         % in a fail-safe way.
  408.    //systemdict begin
  409.         % The PDF specification is somewhat muddy about whether
  410.         % an embedded font's name is supposed to be the BaseFont
  411.         % from the Font object or the FontName from the descriptor.
  412.         % Acrobat Distiller requires the former.  Save away the
  413.         % name so we can substitute it at definefont time.
  414.    //readtype1dict dup length 3 add dict copy begin
  415.    1 index /BaseFont oget /savedFontName exch def
  416.    /topFontDict null def
  417.    /readtype1dictcopy currentdict def
  418.     { run } aload pop count 1 sub 2 packedarray cvx exec
  419.    end end
  420.    count exch sub { pop } repeat
  421.    PDFfile 3 -1 roll setfileposition
  422.    /BaseFont oget findfont
  423.    adjustfont
  424.  } bdef
  425.  
  426. % Execute the appropriate reading procedure.
  427. /type1read        % <dict> type1read <string>
  428.  { begin leftstr cvi
  429.     { type1read0 type1read1 type1read2 type1read3 } sectionstr 0 get get exec
  430.    (          ) leftstr copy cvs pop end
  431.  } bdef
  432.  
  433. % Read the next block of data into the buffer.
  434. /type1readdata        % <left> <buffer> type1readdata <substring> <left'>
  435.  { 0 2 index 2 index length .min getinterval
  436.         % Adobe requires readstring to signal an error if given
  437.         % an empty string.  Work around this nonsense here.
  438.    dup length 0 ne { data exch readstring pop } if
  439.    dup length 3 -1 roll exch sub
  440.    DEBUG
  441.     { dup =only ( read ) print
  442.       1 index length =only (: ) print
  443.       1 index == flush
  444.     } if
  445.  } bdef
  446.  
  447. % Read the initial byte to see if we need to skip a 6 byte PFB header
  448. /type1read0 {         % <left> type1read0 <string> <left'>
  449.   sectionstr 0 1 put    % either way we go to the next stage
  450.   pfbhdr type1readdata
  451.   1 index 0 get 16#80 eq {
  452.     (\n   **** Warning: Embedded Type1 font in PFB format is not valid PDF.)
  453.     pdfformaterror
  454.     DEBUG { (skipping PFB header) = flush } if
  455.     exch pop buffer 0 5 getinterval type1readdata exch
  456.     dup 4 get 256 mul 1 index 3 get add 256 mul
  457.     1 index 2 get add 256 mul 1 index 1 get add
  458.     DEBUG { (PFB segment length = ) print dup = } if
  459.     exch pop  % discard the string keeping the PFB segment length
  460.     2 copy ne {
  461.       (\n   **** Warning: Type 1 PFB segment length and Length 1 value do not match.)
  462.       pdfformaterror
  463.       exch     % keep the PFB length instead
  464.     } if
  465.     pop
  466.     buffer type1readdata    % go ahead and read a block
  467.   }
  468.   if    % if not PFB, return pfbhdr string (first char of file, usually %).
  469. } bdef
  470.  
  471. % Read the next block of the initial text portion.
  472. /type1read1 {        % <left> type1read1 <string> <left'>
  473.   DEBUG { (read1 ) print } if
  474.   dup 0 eq {
  475.     pop sectionstr 0 2 put
  476.     stream /Length2 oget
  477.             % Determine whether to hexify data for eexec.
  478.     dup 8 lt {
  479.       type1read2    % Hexify.
  480.     } {
  481.       DEBUG { (read2 ) print } if
  482.       pfbhdr 0 get 16#80 eq {
  483.         % eat 6 more bytes of PFB junk before proceeding
  484.     DEBUG { (skipping PFB header in segment 2) = flush } if
  485.     buffer 0 6 getinterval type1readdata exch
  486.         dup 5 get 256 mul 1 index 4 get add 256 mul
  487.     1 index 3 get add 256 mul 1 index 2 get add
  488.         DEBUG { (PFB segment length = ) print dup = } if
  489.     exch pop  % discard the string keeping the PFB segment length
  490.     2 copy ne {
  491.           (\n   **** Warning: Type 1 PFB segment length and Length 2 value do not match.)
  492.           pdfformaterror
  493.       dup =
  494.       exch         % keep the PFB length instead
  495.     } if
  496.       pop
  497.       } if
  498.       buffer2 type1readdata exch
  499.             % The check doesn't have to be 100% accurate:
  500.             % hexifying is always OK.
  501.       dup 0 8 getinterval 0 exch { or } forall
  502.       128 ge {
  503.     /hexify { } store
  504.     /buffer2 buffer def    % We don't need an intermediate buffer.
  505.       } if hexify exch
  506.     } ifelse
  507.   } {
  508.     buffer type1readdata
  509.   } ifelse
  510. } bdef
  511.  
  512. % Convert a string from binary to hex for eexec.
  513. % Free variables: buffer.
  514. /buf2hex {        % <string> buf2hex <hexstring>
  515.   buffer /ASCIIHexEncode filter dup 3 -1 roll writestring closefile
  516.   buffer (>) search pop exch pop exch pop
  517. } bdef
  518.  
  519. % Read the next block of the encrypted portion.
  520. /type1trailer
  521. (0000000000000000000000000000000000000000000000000000000000000000\n\
  522. 0000000000000000000000000000000000000000000000000000000000000000\n\
  523. 0000000000000000000000000000000000000000000000000000000000000000\n\
  524. 0000000000000000000000000000000000000000000000000000000000000000\n\
  525. 0000000000000000000000000000000000000000000000000000000000000000\n\
  526. 0000000000000000000000000000000000000000000000000000000000000000\n\
  527. 0000000000000000000000000000000000000000000000000000000000000000\n\
  528. 0000000000000000000000000000000000000000000000000000000000000000\n\
  529. cleartomark\n)
  530. readonly def
  531. /type1read2 {        % <left> type1read2 <string> <left'>
  532.   DEBUG { (read2 ) print } if
  533.    dup 0 eq
  534.     { pop sectionstr 0 3 put
  535.       stream /Length3 oget
  536.       dup 0 eq
  537.        { DEBUG { (trailer ) print } if
  538.      type1trailer exch
  539.        }
  540.        { 
  541.          pfbhdr 0 get 16#80 eq {
  542.            % eat 6 more bytes of PFB junk before proceeding
  543.        DEBUG { (skipping PFB header in segment 3) = flush } if
  544.        buffer 0 6 getinterval type1readdata exch
  545.            dup 5 get 256 mul 1 index 4 get add 256 mul
  546.        1 index 3 get add 256 mul 1 index 2 get add
  547.            DEBUG { (PFB segment length = ) print dup = } if
  548.        exch pop  % discard the string keeping the PFB segment length
  549.        2 copy ne {
  550.            (\n   **** Warning: Type 1 PFB segment length and Length 3 value do not match.)
  551.            pdfformaterror
  552.          exch     % keep the PFB length instead
  553.        } if
  554.        pop
  555.        (\n) pdfformaterror
  556.          } if
  557.          type1read3
  558.        }
  559.       ifelse
  560.     }
  561.     { buffer2 type1readdata exch hexify exch
  562.     }
  563.    ifelse
  564. } bdef
  565.  
  566. % Read the next block of the final text portion.
  567. % When finished, this procedure returns an empty string.
  568. /type1read3        % <left> type1read3 <string> <left'>
  569.  { DEBUG { (read3 ) print } if
  570.    buffer type1readdata
  571.  } bdef
  572.  
  573. % ---------------- Type 3 fonts ---------------- %
  574.  
  575. /.notdefEncoding 256 { /.notdef } repeat 256 packedarray def
  576.  
  577. /buildType3 {        % <Type3-font-resource> buildType3 <font>
  578.   8 dict begin
  579.     /FontType 3 def
  580.     /Resources 1 index /Resources knownoget { oforce } { 0 dict } ifelse def
  581.     /FontBBox 1 index /FontBBox get cvx def
  582.     /FontMatrix 1 index /FontMatrix oget def
  583.     /CharProcs 1 index /CharProcs oget def
  584.     1 index /Widths knownoget {
  585.       /Widths exch def
  586.       /FirstChar 1 index /FirstChar oget def
  587.       /LastChar 1 index /LastChar oget def
  588.     } if
  589.     /FontName 1 index /Name get genfontname def
  590.     /Encoding .notdefEncoding 2 index getencoding def
  591.         % We have to define BuildChar rather than BuildGlyph:
  592.         % there is no PDF equivalent of glyphshow, and we need
  593.         % the character code to access the Widths.
  594.     /BuildChar {
  595.         % Stack: font charcode
  596.       1 index begin 3 dict begin
  597.       /Font 3 -1 roll def /CharCode 1 index def
  598.       % Make unknown characters map to /.notdef
  599.       Encoding exch get dup CharProcs exch known
  600.         { CharProcs exch oget }
  601.     { pop CharProcs /.notdef oget }
  602.       ifelse
  603.       PDFfile fileposition exch
  604.       false resolvestream
  605.         % Stack: filepos stream
  606.         % Don't let setgcolor set the color inside the BuildGlyph
  607.         % procedure, because this causes an /undefined error.
  608.       q null /FillColor gput null /StrokeColor gput
  609.       Font /Resources get exch pdfopdict .pdfruncontext
  610.       Q
  611.       PDFfile exch setfileposition
  612.       end end
  613.     } bdef
  614.     FontName currentdict end definefont exch pop
  615. } bdef
  616. /.adjustcharwidth {    % <wx> <wy> .adjustcharwidth <wx'> <wy'>
  617.   /Widths where {
  618.     begin
  619.     CharCode FirstChar ge CharCode LastChar le and {
  620.       exch pop Widths CharCode FirstChar sub get exch
  621.     } if end
  622.   } if
  623. } bdef
  624.  
  625. % ---------------- TrueType fonts ---------------- %
  626.  
  627. /TTfonts mark
  628.   /Arial /Helvetica
  629.   /Arial,Italic /Helvetica-Oblique
  630.   /Arial,Bold /Helvetica-Bold
  631.   /Arial,BoldItalic /Helvetica-BoldOblique
  632.   /CourierNew /Courier
  633.   /CourierNew,Bold /Courier-Bold
  634.   /TimesNewRoman /Times-Roman
  635.   /TimesNewRoman,Italic /Times-Italic
  636.   /TimesNewRoman,Bold /Times-Bold
  637.   /TimesNewRoman,BoldItalic /Times-BoldItalic
  638.   %
  639.   /ArialBlack,Italic /Arial-BlackItalic
  640.   /ArialNarrow,Bold /ArialNarrow-Bold
  641.   /ArialNarrow,BoldItalic /ArialNarrow-BoldItalic
  642.   /ArialNarrow,Italic /ArialNarrow-Italic
  643.   /BookAntiqua,Bold /BookAntiqua-Bold
  644.   /BookAntiqua,BoldItalic /BookAntiqua-BoldItalic
  645.   /BookAntiqua,Italic /BookAntiqua-Italic
  646.   /BookmanOldStyle,Bold /BookmanOldStyle-Bold
  647.   /BookmanOldStyle,BoldItalic /BookmanOldStyle-BoldItalic
  648.   /BookmanOldStyle,Italic /BookmanOldStyle-Italic
  649.   /CenturyGothic,Bold /CenturyGothic-Bold
  650.   /CenturyGothic,BoldItalic /CenturyGothic-BoldItalic
  651.   /CenturyGothic,Italic /CenturyGothic-Italic
  652.   /ComicSansMS,Bold /ComicSansMS-Bold
  653.   /CourierNew,Bold /CourierNewPS-BoldMT
  654.   /CourierNew,BoldItalic /CourierNewPS-BoldItalicMT
  655.   /CourierNew,Italic /CourierNewPS-ItalicMT
  656.   /FranklinGothicMedium,Italic /FranklinGothic-MediumItalic
  657.   /Garamond,Bold /Garamond-Bold
  658.   /Garamond,Italic /Garamond-Italic
  659.   /Georgia,Bold /Georgia-Bold
  660.   /Georgia,BoldItalic /Georgia-BoldItalic
  661.   /Georgia,Italic /Georgia-Italic
  662.   /Tahoma,Bold /Tahoma-Bold
  663.   /TrebuchetMS,Bold /TrebuchetMS-Bold
  664.   /TrebuchetMS,BoldItalic /Trebuchet-BoldItalic
  665.   /TrebuchetMS,Italic /TrebuchetMS-Italic
  666.   /Verdana,Bold /Verdana-Bold
  667.   /Verdana,BoldItalic /Verdana-BoldItalic
  668.   /Verdana,Italic /Verdana-Italic
  669. .dicttomark readonly def
  670.  
  671. /buildTrueType {    % <TrueType-font-resource> buildTrueType <font>
  672.   dup /BaseFont get
  673.   dup TTfonts exch .knownget {
  674.     exch pop
  675.         % Hack required by the PDF specification: if the
  676.         % font resource has Subtype = /TrueType but the actual
  677.         % (installed) font is not a TrueType font, ignore the
  678.         % Encoding in the font resource.  However, all current
  679.         % versions of Acrobat Reader have the 14 base TrueType
  680.         % fonts built in, so this produces incorrect output for
  681.         % badly designed PDF files that specify these file names
  682.         % with /Subtype = /TrueType but no embedded definition.
  683.         % Compensate for this by removing the /Subtype key when
  684.         % looking up the font.
  685.     exch dup length dict copy dup /Subtype null put exch
  686.   } if
  687.   pdffindfont    % findfont for PDF
  688.   % disable the auto-bold and auto-italic since it sometimes applies
  689.   % so an already bold or italic substitute font
  690.   %findpdffont    % findfont and auto-bold and/or auto-italic font for PDF
  691. } bdef
  692.  
  693. % Read an embedded TrueType font.
  694. /readtruetype {        % <font-resource> <stream-dict> readtruetype <font>
  695.         % This is much simpler than readtype1, because we don't
  696.         % have to deal with the tripartite .PFB format.
  697.   1 index exch
  698.   PDFfile fileposition 3 1 roll
  699.   true resolvestream readfontfilter
  700.         % Stack: filepos fontres stream
  701.   1 index /Subtype get /CIDFontType2 eq {
  702.     .loadttcidfont
  703.         % Stack: filepos fontres cidfont
  704.     1 index /CIDToGIDMap knownoget {
  705.       dup /Identity eq {
  706.     pop
  707.       } {
  708.     true resolvestream
  709.         % The following doesn't work for CIDToGIDMaps with more
  710.         % than 32K-1 entries.  We'll fix it later if necessary.
  711.         % Stack: filepos fontres font mapstream
  712.     dup 2 index /CIDCount oget 2 mul string readstring pop exch closefile
  713.     exch dup length 5 add dict .copydict
  714.     dup /FID undef
  715.     dup /CIDMap 4 -1 roll put
  716.     dup /CIDFontName get exch /CIDFont defineresource
  717.       } ifelse
  718.     } if
  719.   } {
  720.     null 2 index getencoding .loadpdfttfont
  721.   } ifelse
  722.   exch pop
  723.   PDFfile 3 -1 roll setfileposition
  724.         % Ignore both the Encoding and the Widths.
  725.   exch pop
  726. } bdef
  727.  
  728. % ---------------- Type 0 fonts ---------------- %
  729.  
  730. % Predefine the known CMaps, but only create them on demand.
  731. /knownCMaps mark
  732.   /Identity-H { /Identity-H 0 makeIdentityCMap }
  733.   /Identity-V { /Identity-V 1 makeIdentityCMap }
  734. .dicttomark def
  735.  
  736. /makeIdentityCMap {        % <cmapname> <wmode> .makeIdentityCMap -
  737.   .currentglobal true .setglobal 3 1 roll
  738.   /CIDInit /ProcSet findresource begin
  739.   12 dict begin
  740.     begincmap
  741.     /WMode exch def
  742.     /CMapName exch def
  743.     /CIDSystemInfo 3 dict dup begin
  744.       /Registry (Adobe) def
  745.       /Ordering (Identity) def
  746.       /Supplement 0 def
  747.     end def
  748.     %/CMapName (see above)
  749.     /CMapVersion 1 def
  750.     /CMapType 1 def
  751.     %WMode (see above)
  752.     % The PDF documentation says that these CMaps map CIDs
  753.     % "1 to 65,536".  This is a misprint for 0 to 65,535.
  754.     1 begincodespacerange
  755.     % <0001> <00ff>  <0100> <ffff>
  756.       <0000> <ffff>
  757.     endcodespacerange
  758.     1 begincidrange
  759.     % <0001> <00ff> 1   <0100> <ffff> 256
  760.       <0000> <ffff> 0
  761.     endcidrange
  762.     endcmap
  763.     CMapName currentdict /CMap defineresource
  764.     knownCMaps CMapName 2 index put
  765.   end        % CMap
  766.   end        % CIDInit ProcSet
  767.   exch .setglobal
  768. } bdef
  769.  
  770. /buildType0 {        % <Type0-font-resource> buildType0 <font>
  771.   dup /BaseFont get    % FontName
  772.   1 index /Encoding oget
  773.   dup type /nametype eq {
  774.     dup /CMap resourcestatus {
  775.     pop pop /CMap findresource
  776.     } {
  777.     knownCMaps 1 index .knownget
  778.       { exch pop exec } { /undefined signalerror } ifelse
  779.     } ifelse
  780.   } {
  781.     PDFfile fileposition exch
  782.     dup /CMapName get exch true resolvestream cvx exec
  783.     /CMap findresource
  784.     exch PDFfile exch setfileposition
  785.   } ifelse        % CMap
  786.   [
  787.     3 index /DescendantFonts oget { exec resourcefont } forall
  788.   ]            % subfonts
  789.   composefont
  790.         % Stack: fontres font
  791.   1 index /FontMatrix knownoget {
  792.     dup aload pop true {0 0 1 0 0 1} {3 -1 roll eq and} forall {
  793.       1 index exch makefont exch /FontName get exch definefont
  794.     } {
  795.       pop
  796.     } ifelse
  797.   } if exch pop
  798. } bdef
  799.  
  800. % ---------------- CIDFontType0/2 fonts ---------------- %
  801.  
  802. % Insert metrics into a CIDFont, by saving the PDF W, W2, DW, and DW2
  803. % arrays and using a (currently very inefficient) CDevProc.
  804. % For detail, refer "PDF Reference" third edition, p. 337,
  805. % "5.6.3 CIDFonts" and table "Entries in a CIDFont dictionary".
  806.  
  807. /.pdfDefaultDW  1000 def
  808. /.pdfDefaultDW2 [ 880 -1000 ] def
  809.  
  810. /addCIDmetrics {    % <CIDFont-resource> <CIDFont> addCIDmetrics <fontdict>
  811.   dup length 5 add dict .copydict
  812.   dup /FID undef
  813.   dup /UniqueID undef
  814.   dup /XUID undef
  815.     % Insert the widths into the font.
  816.  
  817.     % Stack: pdfresource newfont
  818.  
  819.   1 index /DW .knownget {
  820.     1 index /DW 3 -1 roll put
  821.     } {
  822.     dup /DW .pdfDefaultDW put
  823.     } ifelse
  824.  
  825.  
  826.   1 index /W .knownget {
  827.     dup 2 index /W 3 -1 roll put
  828.     .pdfMakeInternalW 1 index /.internalW 3 -1 roll put
  829.   } if
  830.  
  831.  
  832.   1 index /DW2 .knownget {
  833.     1 index /DW2 3 -1 roll put
  834.   } {
  835.     dup /DW2 .pdfDefaultDW2 put
  836.   } ifelse
  837.  
  838.  
  839.   1 index /W2 .knownget {
  840.     dup 2 index /W2 3 -1 roll put
  841.     .pdfMakeInternalW2 1 index /.internalW2 3 -1 roll put
  842.   } if
  843.  
  844.  
  845.   dup /CDevProc 1 index /CIDWProc load /exec load 3 packedarray cvx put
  846.   exch pop
  847. } bdef
  848.  
  849. /.pdfMakeInternalMTXArray { % <mtx_array> <item_size> .pdfConvertInternalW <mtx_array'>
  850.  
  851.   % convert /W or /W2 to internal expression
  852.   %
  853.   %   mtx_array: original /W or /W2 array
  854.   %   item_size: number of metrics values per CID
  855.   %
  856.   %   for detail of the metrics list format in PDF,
  857.   %   refer PDF Ref. p.317 "Glyph Metrics in CIDFonts".
  858.   % 
  859.   %   format of single entry in internal expression
  860.   %
  861.   %     [
  862.   %       [cid_begin cid_end]
  863.   %       value_is_varied (bool)
  864.   %       [ [values for cid_begin...]
  865.   %         [values for cid_begin + 1]
  866.   %         ... ]
  867.   %     ]
  868.   %
  869.  
  870.   7 dict
  871.   begin
  872.     /itemSize exch def
  873.     /M exch def            % original /W or /W2
  874.     /Msize M length def
  875.     /Mi { M i get } def        % W[i]
  876.     /Mi1 { M i 1 add get } def    % W[i + 1]
  877.     /putMTXEntry <<
  878.       /arraytype   {
  879.          [
  880.            [Mi Mi Mi1 length add 1 sub]
  881.            true
  882.            [
  883.              0 itemSize Mi1 length 1 sub {
  884.                [ exch 1 1 index itemSize add 1 sub { Mi1 exch get } for ]
  885.              } for
  886.            ]
  887.          ]
  888.          /i i 2 add def
  889.       }
  890.       /integertype {
  891.          [
  892.            [Mi Mi1]
  893.            false
  894.            [[ i 2 add 1 i 1 add itemSize add { M exch get } for ]]
  895.          ]
  896.          /i i 3 add def
  897.       }
  898.     >> def
  899.  
  900.     /i 0 def
  901.  
  902.     [ { putMTXEntry Mi1 type get exec i Msize ge { exit } if } loop ]
  903.   end
  904. } def
  905.  
  906. /.pdfMakeInternalW  { dup length 0 gt { 1 .pdfMakeInternalMTXArray } if } def
  907. /.pdfMakeInternalW2 { dup length 0 gt { 3 .pdfMakeInternalMTXArray } if } def
  908.  
  909. /.pdfGetMTXByCID { % <internalMTXArray> <cid>
  910.                    %     .pdfGetMTXByCID
  911.                    %         { <MTXEntry> true | false }
  912.  
  913.   % get values for given CID from internal format of /W or /W2
  914.  
  915.   exch
  916.   {
  917.     {
  918.       dup 0 get {} forall      % Stack: <cid> <entry> <cid_0> <cid_1>
  919.       3 index lt { pop pop false exit } if
  920.       2 index exch sub dup 0 lt { pop pop false exit } if
  921.       1 index 1 get not { pop 0 } if
  922.       exch 2 get exch get true exit
  923.     } loop
  924.     { exit } if
  925.   } forall
  926.   dup type /arraytype eq { exch pop true } { pop false } ifelse
  927. } def
  928.  
  929.  
  930. % Apply the [D]W[2] metrics to a character before displaying.
  931. /CIDWProc {        % <w0x> <w0y> <llx> <lly> <urx> <ury>
  932.             %   <w1x> <w1y> <vx> <vy> <cid> <font> CIDWproc
  933.             %   <w0x'> ... <vy'>
  934.  
  935.   begin % push <font> to currentdict
  936.     % <w1x> <w1y> <vx> <vy> won't be used and replaced, discard now
  937.     5 1 roll pop pop pop pop
  938.  
  939.     {
  940.       currentdict /DW .knownget not {   % no DW
  941.         .pdfDefaultDW exit              % replace <w0x> by defaultDW
  942.       } if
  943.  
  944.       currentdict /.internalW .knownget not {    % no W
  945.         exit                            % use already-stacked DW
  946.       } if
  947.  
  948.       dup length 0 eq {                 % W is null array
  949.         pop                             % discard unusable W
  950.         exit                            % use already-stacked DW
  951.       } if
  952.  
  953.       % W is finite array, try to get W_cid
  954.       2 index .pdfGetMTXByCID {           % got W, discard DW
  955.         exch pop {} forall
  956.         exit
  957.       } if
  958.  
  959.       exit
  960.     } loop
  961.  
  962.     1000 div                    % <w0x'> (normalized W)
  963.     0                           % <w0y'>
  964.  
  965.     % Stack: <w0x> <w0y> <llx> <lly> <urx> <ury> <cid> <w0x'> <w0y'>
  966.     9 -2 roll pop pop           % discard <w0x> <w0y>
  967.     7  2 roll                   % put <w0x'> <w0y'>
  968.  
  969.     % Stack: <w0x'> <w0y'> <llx> <lly> <urx> <ury> <cid>
  970.     0                           % <w1x'>
  971.     exch                        % put <w1x'>
  972.  
  973.     % Stack: <w0x'> <w0y'> <llx> <lly> <urx> <ury> <w1x'> <cid>
  974.     {
  975.       currentdict /DW2 .knownget not {  % no DW2, use defaultDW2
  976.         .pdfDefaultDW2 exit
  977.       } if
  978.  
  979.       currentdict /.internalW2 .knownget not {   % has DW2, no W2
  980.         exit                            % use already-stacked DW2
  981.       } if
  982.  
  983.       dup length 0 eq {                 % W2 is null array
  984.         pop                             % discard unusable W2
  985.         exit                            % use already-stacked DW2
  986.       } if
  987.  
  988.       2 index .pdfGetMTXByCID {        % got W2_cid, discard DW2
  989.         exch pop
  990.         exit
  991.       } if
  992.  
  993.       % could not get W2_cid
  994.       exit
  995.  
  996.     } loop
  997.  
  998.     exch pop                            % discard <cid>
  999.  
  1000.  
  1001.     % Stack: <w0x'> <w0y'> <llx> <lly> <urx> <ury> <w1x'> { [<vy'> <w1y'>] | [<w1y'> <vx'> <vy'>] }
  1002.     dup length 2 eq {                   % this is DW2
  1003.       {1000 div} forall exch
  1004.       4 index 7 index add 2 div         % <vx'> = (<urx> + <llx>) / 2
  1005.       exch
  1006.     }{                                  % assume W2
  1007.       {1000 div} forall
  1008.     } ifelse
  1009.   end                                   % recover currentdict
  1010.  
  1011. } def
  1012.  
  1013.  
  1014.  
  1015. %----------------------------------------------------------------
  1016.  
  1017. % <string> <match> tailmatch ==> <pre> true
  1018. %                            ==> <string> false
  1019. /tailmatch {
  1020.   2 copy length 1 index length .min
  1021.   dup 2 index length exch sub exch getinterval
  1022.   1 index eq {
  1023.     length 1 index length exch sub
  1024.     0 exch getinterval true
  1025.   } {
  1026.     pop false
  1027.   } ifelse
  1028. } bind def
  1029.  
  1030. /makeboldcidfont {
  1031.   16 dict begin
  1032.     /strokewidth exch def
  1033.     /basecidfont exch def
  1034.     /FontMatrix [ 1 0 0 1 0 0 ] def
  1035.  
  1036.     /CIDFontName /.boldfont def
  1037.     /CIDFontType 1 def
  1038.  
  1039.     /basefont-H /.basefont-H /Identity-H [ basecidfont ] composefont def
  1040.     /basefont-V /.basefont-V /Identity-V [ basecidfont ] composefont def
  1041.  
  1042.     /CIDSystemInfo dup basecidfont exch get def
  1043.     /FontBBox [ basecidfont /FontBBox get cvx exec
  1044.       4 2 roll basecidfont /FontMatrix get transform
  1045.       4 2 roll basecidfont /FontMatrix get transform
  1046.     ] def
  1047.  
  1048.     /tmpstr 2 string def
  1049.     /BuildGlyph {
  1050.       gsave
  1051.       exch begin
  1052.         dup 256 idiv tmpstr exch 0 exch put
  1053.         256 mod tmpstr exch 1 exch put
  1054.         rootfont /WMode known { rootfont /WMode get 1 eq } { false } ifelse
  1055.         { basefont-V } { basefont-H } ifelse setfont
  1056.         strokewidth setlinewidth
  1057.         1 setlinejoin
  1058.         newpath
  1059.         0 0 moveto tmpstr false charpath stroke
  1060.         0 0 moveto tmpstr show
  1061.         currentpoint setcharwidth
  1062.       end
  1063.       grestore
  1064.     } bind def
  1065.  
  1066.    currentdict
  1067.   end
  1068.   dup /CIDFontName get exch /CIDFont defineresource
  1069. } bind def
  1070.  
  1071. % <CIDFont-resource> <CIDFontName> findCIDFont <CIDFont-resource> <font>
  1072. %   CIDFont-resource is not modified.
  1073. /findCIDFont {
  1074.   {
  1075.     dup /CIDFont resourcestatus {
  1076.       pop pop /CIDFont findresource
  1077.       exit
  1078.     } if
  1079.  
  1080.     dup dup length string cvs
  1081.     (,Bold) tailmatch {
  1082.       exch pop
  1083.       cvn findCIDFont 0.03 makeboldcidfont
  1084.       exit
  1085.     } if
  1086.     (,Italic) tailmatch {
  1087.       exch pop
  1088.       cvn findCIDFont
  1089.       [ 1 0 0.3 1 0 0 ] makefont
  1090.       exit
  1091.     } if
  1092.     (,BoldItalic) tailmatch {
  1093.       exch pop
  1094.       cvn findCIDFont 0.03 makeboldcidfont
  1095.       [ 1 0 0.3 1 0 0 ] makefont
  1096.       exit
  1097.     } if
  1098.     pop
  1099.  
  1100.     1 index /CIDSystemInfo get begin Registry (-) Ordering end
  1101.     concatstrings concatstrings
  1102.     cvn
  1103.     QUIET not {
  1104.       (Substituting ) print dup ==only
  1105.       ( for ) print 1 index ==only (.\n) print
  1106.     } if
  1107.     exch pop
  1108.     /CIDFont findresource
  1109.     exit
  1110.   } loop
  1111. } bdef
  1112.  
  1113. /buildCIDType0 {    % <CIDFontType0-font-resource> buildCIDType0 <font>
  1114.   dup /BaseFont get exch 1 index findCIDFont
  1115.   addCIDmetrics /CIDFont defineresource
  1116. } bdef
  1117.  
  1118. /buildCIDType2 {    % <CIDFontType2-font-resource> buildCIDType2 <font>
  1119.   dup /BaseFont get exch 1 index findCIDFont
  1120.   addCIDmetrics /CIDFont defineresource
  1121. } bdef
  1122.  
  1123. % ---------------- Other embedded fonts ---------------- %
  1124.  
  1125. /fontloadprocs mark
  1126.   /Type1C /readType1C cvx
  1127.   /CIDFontType0C /readCIDFontType0C cvx
  1128. .dicttomark readonly def
  1129.  
  1130. % Read an embedded compressed font.
  1131. /readType1C {        % <font-resource> <stream-dict> readType1C <font>
  1132.   1 index exch
  1133.   PDFfile fileposition 3 1 roll
  1134.   dup true resolvestream dup readfontfilter
  1135.         % Stack: pos resource streamdict stream filter
  1136.   3 index /FontDescriptor oget /FontName oget
  1137.   1 index FRD
  1138.   closefile closefile pop
  1139.   PDFfile 3 -1 roll setfileposition
  1140.   /FontDescriptor oget /FontName oget findfont
  1141.   adjustfont
  1142. } bdef
  1143.  
  1144. % Read an embedded CFF CIDFont.
  1145. /readCIDFontType0C {  % <font-resource> <stream-dict> readCIDFontType0C <font>
  1146.   PDFfile fileposition 3 1 roll
  1147.   dup true resolvestream dup readfontfilter
  1148.         % Stack: pos resource streamdict stream filter
  1149.   3 index /FontDescriptor oget /FontName oget
  1150.   1 index FRD
  1151.   closefile closefile pop
  1152.   PDFfile 3 -1 roll setfileposition
  1153.         % Some broken Adobe software produces PDF files in which
  1154.         % the FontName of the CFF font and the FontName in the
  1155.         % FontDescriptor don't match the BaseFont in the font.
  1156.         % Use the FontName, rather than the BaseFont, here.
  1157.   dup /FontDescriptor oget /FontName oget /CIDFont findresource
  1158.   addCIDmetrics dup /CIDFontName get exch /CIDFont defineresource
  1159. } bdef
  1160.  
  1161. % ---------------- Font lookup ---------------- %
  1162.  
  1163. /fonttypeprocs mark        % <font-resource> -proc- <font>
  1164.   /Type0 /buildType0 cvx
  1165.   /Type1 /buildType1 cvx
  1166.   /MMType1 1 index
  1167.   /Type3 /buildType3 cvx
  1168.   /TrueType /buildTrueType cvx
  1169.   /CIDFontType0 /buildCIDType0 cvx
  1170.   /CIDFontType2 /buildCIDType2 cvx
  1171. .dicttomark readonly def
  1172.  
  1173. /resourcefont            % <font-resource> resourcefont <font>
  1174.  { dup /PSFont .knownget
  1175.     { /FID .knownget { type /fonttype eq } { false } ifelse }
  1176.     { false }
  1177.    ifelse
  1178.     { /PSFont get
  1179.     }
  1180.     { dup dup /FontDescriptor knownoget
  1181.        {    % Stack: font-res font-res font-desc
  1182.      dup /FontFile knownoget
  1183.       { exch pop readtype1 true }
  1184.       { dup /FontFile2 knownoget
  1185.          { exch pop readtruetype true }
  1186.          { /FontFile3 knownoget
  1187.         { dup /Subtype get fontloadprocs exch get exec true }
  1188.         { false }
  1189.            ifelse
  1190.          }
  1191.         ifelse
  1192.       }
  1193.      ifelse
  1194.        }
  1195.        { false }
  1196.       ifelse
  1197.         % Stack: font-res font-res false
  1198.         %  -or-: font-res font true
  1199.       not
  1200.        { dup /Subtype get fonttypeprocs exch get exec }
  1201.       if
  1202.       2 copy /PSFont exch put
  1203.       exch pop
  1204.     }
  1205.    ifelse
  1206.  } bdef
  1207.  
  1208. drawopdict begin
  1209.   /d0 {
  1210.     .adjustcharwidth setcharwidth
  1211.   } bdef
  1212.   /d1 {
  1213.     6 -2 roll .adjustcharwidth 6 2 roll setcachedevice
  1214.   } bdef
  1215.   /Tf {
  1216.     1 index Page /Font rget not { 1 index /invalidfont signalerror } if
  1217.     resourcefont exch Tf pop
  1218.   } bdef
  1219. end
  1220.  
  1221. end            % pdfdict
  1222. end            % GS_PDF_ProcSet
  1223. .setglobal
  1224.